﻿/* * * * * * * * * * * * * * * *
 * SDL ToolBox                 *
 * Copyright (c) VosSoft 2009  *
 * * * * * * * * * * * * * * * *
 * file:    form einstellungen *
 * date:    2009-05-06         *
 * * * * * * * * * * * * * * * */

using System;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.IO;
using System.Windows.Forms;

namespace SDL_ToolBox
{
    public partial class frmEinstellungen : Form
    {
        private Config config;    // Zeiger auf die Einstellungen
        private Map map;          // Zeiger auf die aktuelle Map
        private DataSet texList;  // Texturen-DB
        private string texFile;   // Speicherort der Texturen-DB
        private int selRow;       // markierte Zeile in der Texturentabelle

        #region frmEinstellungen

        public frmEinstellungen(Config ptrCfg, Map ptrMap)
        {
            InitializeComponent();
            this.FormClosed += new System.Windows.Forms.FormClosedEventHandler(frmEinstellungen_FormClosed);
            this.tabEinstellungen.SelectedIndexChanged += new EventHandler(tabEinstellungen_SelectedIndexChanged);
            this.tabTexturen.RowEnter += new DataGridViewCellEventHandler(tabTexturen_RowEnter);
            this.tabTexturen.RowsRemoved += new DataGridViewRowsRemovedEventHandler(tabTexturen_RowsRemoved);
            this.tabTexturen.CellDoubleClick += new DataGridViewCellEventHandler(tabTexturen_CellDoubleClick);
            this.tabTexturen.CellEndEdit += new System.Windows.Forms.DataGridViewCellEventHandler(tabTexturen_CellEndEdit);
            this.tabKategorien.DefaultValuesNeeded += new System.Windows.Forms.DataGridViewRowEventHandler(tabKategorien_DefaultValuesNeeded);
            this.picTexPreview.MouseClick += new MouseEventHandler(picTexPreview_MouseClick);
            this.contextMenuTexturen.Opening+=new CancelEventHandler(contextMenuTexturen_Opening);
            this.umbenennenToolStripTextBox.KeyPress += new KeyPressEventHandler(umbenennenToolStripTextBox_KeyPress);

            config = ptrCfg; // Zeiger auf die Einstellungen von frmMain
            map = ptrMap; // Zeiger auf die Map von frmMain
        }

        private void frmEinstellungen_Load(object sender, EventArgs e)
        {
            try
            {
                // Alle Einstellungen laden
                //config.Load(true);
                // Fensterposition laden
                Left = Convert.ToInt32(config.Sections[Name].Settings["left"].Value);
                Top = Convert.ToInt32(config.Sections[Name].Settings["top"].Value);
                // Map
                if (map.Size > 0) // Map geöffnet
                {
                    numX.Value = map.X;
                    numY.Value = map.Y;
                    numSize.Value = map.Size;
                    txtBackground.Text = new String(map.Background);
                    txtForeground.Text = new String(map.Foreground);
                }
                else
                {
                    numX.Value = Convert.ToInt32(config.Sections["map"].Settings["x"].Value);
                    numY.Value = Convert.ToInt32(config.Sections["map"].Settings["y"].Value);
                    numSize.Value = Convert.ToInt32(config.Sections["map"].Settings["size"].Value);
                    txtBackground.Text = config.Sections["map"].Settings["background"].Value;
                    txtForeground.Text = config.Sections["map"].Settings["foreground"].Value;
                }
                txtMapsPath.Text = config.Sections["map"].Settings["path"].Value;
                // Raster
                picRaster.BackColor = Color.FromArgb(Convert.ToInt32(config.Sections["grid"].Settings["color"].Value));
                trackRaster.Value = Convert.ToInt32(config.Sections["grid"].Settings["alpha"].Value);
                trackRaster_ValueChanged(sender, e);
                cmbRaster.SelectedItem = config.Sections["grid"].Settings["style"].Value;
                numRaster.Value = Convert.ToInt32(config.Sections["grid"].Settings["width"].Value);
                // Auswahl
                picAuswahl.BackColor = Color.FromArgb(Convert.ToInt32(config.Sections["selection"].Settings["color"].Value));
                trackAuswahl.Value = Convert.ToInt32(config.Sections["selection"].Settings["alpha"].Value);
                trackAuswahl_ValueChanged(sender, e);
                cmbAuswahl.SelectedItem = config.Sections["selection"].Settings["style"].Value;
                numAuswahl.Value = Convert.ToInt32(config.Sections["selection"].Settings["width"].Value);
                // Ressourcen
                txtResourcesPath.Text = config.Sections["resources"].Settings["path"].Value;
                // Texturen
                txtTexturenPfad.Text = config.Sections["textures"].Settings["path"].Value;

                // Speicherort der Texturen-DB, liegt immer im Texturenverzeichnis
                texFile = Path.Combine(txtTexturenPfad.Text, "index.xml");

                // Größe des Fensters anpassen
                tabEinstellungen_SelectedIndexChanged(sender, e);

                status.Text = "Die Einstellungen wurden geladen.";
            }
            catch (Exception ex)
            {
                MessageBox.Show(ex.Message, "Fehler", MessageBoxButtons.OK, MessageBoxIcon.Error);
            }
        }

        private void frmEinstellungen_FormClosed(object sender, EventArgs e)
        {
            // Fensterposition speichern
            config.Sections[Name].Settings["left"].Value = Left.ToString();
            config.Sections[Name].Settings["top"].Value = Top.ToString();
            config.Save();
        }

        #endregion

        #region Formularschaltflächen

        private void tabEinstellungen_SelectedIndexChanged(object sender, EventArgs e)
        {
            status.Text = "";
            switch (tabEinstellungen.SelectedIndex)
            {
                case 0: // Tab Allgemein
                    tabEinstellungen.Height = 450;
                    break;
                case 1: // Tab Texturen
                    tabEinstellungen.Height = 682;
                    if (texList == null)
                    {
                        // Texturen-DB öffnen oder erstellen, wenn nicht vorhanden
                        if (OpenTextures() == false)
                        {
                            CreateTextures();
                            MessageBox.Show("Die Texturen-DB \"" + texFile + "\" wurde nicht gefunden, es wird eine neue erstellt.", "Texturen-DB nicht gefunden", MessageBoxButtons.OK, MessageBoxIcon.Information);
                            LoadTextures(txtTexturenPfad.Text);
                        }
                    }
                    break;
                default:
                    break;
            }
            Height = tabEinstellungen.Height + 105;
        }

        private void btnSave_Click(object sender, EventArgs e)
        {
            try
            {
                // Einstellungen speichern
                // Map
                if (map.Size > 0) // Map geöffnet
                {
                    //map.X = (int)numX.Value;
                    //map.Y = (int)numY.Value;
                    //map.Size = (int)numSize.Value;
                    map.Background = new char[10];
                    txtBackground.Text.ToCharArray().CopyTo(map.Background, 0);
                    ToolBox.zeroToSpace(map.Background);
                    map.Foreground = new char[10];
                    txtForeground.Text.ToCharArray().CopyTo(map.Foreground, 0);
                    ToolBox.zeroToSpace(map.Foreground);
                }
                else
                {
                    config.Sections["map"].Settings["x"].Value = numX.Value.ToString();
                    config.Sections["map"].Settings["y"].Value = numY.Value.ToString();
                    config.Sections["map"].Settings["size"].Value = numSize.Value.ToString();
                    config.Sections["map"].Settings["path"].Value = txtMapsPath.Text;
                    config.Sections["map"].Settings["background"].Value = txtBackground.Text;
                    config.Sections["map"].Settings["foreground"].Value = txtForeground.Text;
                }
                // Raster
                config.Sections["grid"].Settings["color"].Value = picRaster.BackColor.ToArgb().ToString();
                config.Sections["grid"].Settings["alpha"].Value = trackRaster.Value.ToString();
                config.Sections["grid"].Settings["style"].Value = cmbRaster.SelectedItem.ToString();
                config.Sections["grid"].Settings["width"].Value = numRaster.Value.ToString();
                // Auswahl
                config.Sections["selection"].Settings["color"].Value = picAuswahl.BackColor.ToArgb().ToString();
                config.Sections["selection"].Settings["alpha"].Value = trackAuswahl.Value.ToString();
                config.Sections["selection"].Settings["style"].Value = cmbAuswahl.SelectedItem.ToString();
                config.Sections["selection"].Settings["width"].Value = numAuswahl.Value.ToString();
                // Ressourcen
                config.Sections["resources"].Settings["path"].Value = txtResourcesPath.Text;
                // Texturen
                config.Sections["textures"].Settings["path"].Value = txtTexturenPfad.Text;

                config.Save();

                // die komplette Texturen-DB in eine XML-Datei schreiben
                if (texList != null)
                {
                    texList.WriteXml(texFile, XmlWriteMode.WriteSchema);
                }
            }
            catch (Exception ex)
            {
                MessageBox.Show(ex.Message, "Fehler beim Speichern", MessageBoxButtons.OK, MessageBoxIcon.Error);
            }
            Close();
        }

        private void btnCancel_Click(object sender, EventArgs e)
        {
            Close();
        }

        #endregion

        #region Tab Allgemein

        private void picRaster_Click(object sender, EventArgs e)
        {
            dlgColor.Color = picRaster.BackColor;
            dlgColor.ShowDialog();
            picRaster.BackColor = dlgColor.Color;
        }

        private void trackRaster_ValueChanged(object sender, EventArgs e)
        {
            lblRaster.Text = Math.Round((trackRaster.Value / 255.0) * 100.0, 0) + " %";
        }

        private void picAuswahl_Click(object sender, EventArgs e)
        {
            dlgColor.Color = picAuswahl.BackColor;
            dlgColor.ShowDialog();
            picAuswahl.BackColor = dlgColor.Color;
        }

        private void trackAuswahl_ValueChanged(object sender, EventArgs e)
        {
            lblAuswahl.Text = Math.Round((trackAuswahl.Value / 255.0) * 100.0, 0) + " %";
        }

        private void btnMapsBrowse_Click(object sender, EventArgs e)
        {
            dlgFolder.Description = "Map-Verzeichnis öffnen:";
            dlgFolder.SelectedPath = txtMapsPath.Text;
            if (dlgFolder.ShowDialog() == DialogResult.OK)
            {
                txtMapsPath.Text = dlgFolder.SelectedPath;
            }
        }

        private void btmResourcesBrowse_Click(object sender, EventArgs e)
        {
            dlgFolder.Description = "Ressourcen-Verzeichnis öffnen:";
            dlgFolder.SelectedPath = txtResourcesPath.Text;
            if (dlgFolder.ShowDialog() == DialogResult.OK)
            {
                txtResourcesPath.Text = dlgFolder.SelectedPath;
            }
        }

        #endregion

        #region Tab Texturen

        private void btnTexturesBrowse_Click(object sender, EventArgs e)
        {
            dlgFolder.Description = "Texturen-Verzeichnis öffnen:";
            dlgFolder.SelectedPath = txtTexturenPfad.Text;
            if (dlgFolder.ShowDialog() == DialogResult.OK)
            {
                txtTexturenPfad.Text = dlgFolder.SelectedPath;
            }
        }

        private void btnScan_Click(object sender, EventArgs e)
        {
            LoadTextures(txtTexturenPfad.Text);
        }

        private void tabTexturen_RowEnter(object sender, DataGridViewCellEventArgs e)
        {
            if (tabTexturen[0, e.RowIndex].Value != null)
            {
                string fileName = tabTexturen[0, e.RowIndex].Value.ToString();
                string path = Path.Combine(txtTexturenPfad.Text, fileName);
                if (File.Exists(path) == true)
                {
                    Bitmap bmp;
                    using (Image img = Image.FromFile(path))
                    {
                        bmp = new Bitmap(img);
                    }
                    tabEinstellungen.Height = grpTexturvorschau.Top + bmp.Height + 138;
                    Height = tabEinstellungen.Height + 105;
                    grpTexturvorschau.Width = bmp.Width + 16;
                    grpTexturvorschau.Height = bmp.Height + 26;
                    picTexPreview.Width = bmp.Width;
                    picTexPreview.Height = bmp.Height;
                    picTexPreview.Image = bmp;
                    selRow = e.RowIndex;
                    if (fileName.Length > 9)
                    {
                        status.Text = "Der Dateiname der Textur ist zu lang (maximal 9 Zeichen inkl. Dateiendung)!";
                    }
                    else
                    {
                        status.Text = "Zum Auswählen des Colorkeys einfach den Bildpixel in der Texturvorschau anklicken.";
                    }
                }
                else
                {
                    picTexPreview.Image = null;
                    selRow = -1;
                    status.Text = "Die Texturendatei \"" + fileName + "\" wurde nicht gefunden!";
                }
            }
        }

        private void tabTexturen_RowsRemoved(object sender, DataGridViewRowsRemovedEventArgs e)
        {
            ShowLoadCount();
        }

        private void tabTexturen_CellDoubleClick(object sender, DataGridViewCellEventArgs e)
        {
            if (e.ColumnIndex == 2) // Spalte colorkey
            {
                dlgColor.Color = Color.FromArgb(Convert.ToInt32(tabTexturen[2, e.RowIndex].Value));
                dlgColor.ShowDialog();
                tabTexturen[e.ColumnIndex, e.RowIndex].Style.BackColor = dlgColor.Color;
                tabTexturen[e.ColumnIndex, e.RowIndex].Value = dlgColor.Color.ToArgb().ToString();
            }
        }

        private void tabTexturen_CellEndEdit(object sender, DataGridViewCellEventArgs e)
        {
            if (e.ColumnIndex == 3) // Spalte "Textur laden"
            {
                // wenn die Texturendatei nicht existiert oder der Dateiname zu lang ist
                if (File.Exists(Path.Combine(txtTexturenPfad.Text, tabTexturen.Rows[e.RowIndex].Cells[0].Value.ToString())) == false || tabTexturen.Rows[e.RowIndex].Cells[0].Value.ToString().Length > 9)
                {
                    // kann die Textur nicht geladen werden!
                    tabTexturen.Rows[e.RowIndex].Cells[3].Value = false;
                }
                ShowLoadCount();
            }
            // wenn der Wert der ComboBox verändert wurde, den Wert zurück in die Spalte cid schreiben
            if (e.ColumnIndex == 5) // Spalte der Kategorie
            {
                tabTexturen[4, e.RowIndex].Value = tabTexturen[5, e.RowIndex].Value;
            }
            // Zeileneigenschaften anpassen
            ShowRowProperties(e.RowIndex, e.RowIndex, false);
        }

        private void tabKategorien_DefaultValuesNeeded(object sender, DataGridViewRowEventArgs e)
        {
            // default-Value für die cid (max + 1)
            e.Row.Cells[0].Value = Convert.ToInt32(texList.Tables[1].Compute("MAX(cid)", "")) + 1;
        }

        private void picTexPreview_MouseClick(object sender, MouseEventArgs e)
        {
            if (picTexPreview.Image != null)
            {
                Bitmap bmp = new Bitmap(picTexPreview.Image);
                tabTexturen[2, selRow].Value = bmp.GetPixel(e.X, e.Y).ToArgb().ToString();
                tabTexturen[2, selRow].Style.BackColor = bmp.GetPixel(e.X, e.Y);
                bmp.Dispose();
            }
        }

        // Anzahl der marierten Zeilen zum Laden der Textur
        private int GetLoadCount()
        {
            int anzahl = 0;
            for (int i = 0; i < tabTexturen.Rows.Count; i++)
            {
                if (tabTexturen.Rows[i].Cells[3].Value.ToString() == "True")
                {
                    anzahl++;
                }
            }
            return anzahl;
        }

        private void ShowLoadCount()
        {
            grpTexturen.Text = "Texturen (" + GetLoadCount() + " von " + tabTexturen.Rows.Count + " Texturen zum Laden markiert)";
        }

        private void CreateTextures()
        {
            texList = new DataSet("texturedatabase");
            texList.Namespace = "SDL_ToolBox";
            DataTable table;
            DataColumn column;
            DataColumn[] keys = new DataColumn[1];
            DataRelation rel;
            //DataRow row;

            // CREATE TABLE texture
            table = new DataTable("texture", "SDL_ToolBox");

            // Feld[0] = Name der Textur (Primärschlüssel)
            column = new DataColumn("name", System.Type.GetType("System.String"));
            table.Columns.Add(column);
            keys[0] = column;

            // Feld[1] = Blockgröße der Textur
            column = new DataColumn("size", Type.GetType("System.Int32"));
            table.Columns.Add(column);

            // Feld[2] = Colorkey der Textur
            column = new DataColumn("colorkey", Type.GetType("System.Int32"));
            table.Columns.Add(column);

            // Feld[3] = Textur Laden (Ja/Nein)
            column = new DataColumn("load", Type.GetType("System.Boolean"));
            table.Columns.Add(column);

            // Feld[4] = Kategorie-ID (Fremdschlüssel)
            column = new DataColumn("cid", System.Type.GetType("System.Int32"));
            table.Columns.Add(column);

            // Primärschlüssel (textur.name)
            table.PrimaryKey = keys;

            // Tabelle an die DB anhängen
            texList.Tables.Add(table);

            // CREATE TABLE category
            table = new DataTable("category", "SDL_ToolBox");

            // Feld[0] = ID der Kategorie (Primärschlüssel)
            column = new DataColumn("cid", System.Type.GetType("System.Int32"));
            table.Columns.Add(column);
            keys[0] = column;

            // Feld[1] = Name der Kategorie
            column = new DataColumn("name", Type.GetType("System.String"));
            table.Columns.Add(column);

            // Primärschlüssel (category.cid)
            table.PrimaryKey = keys;

            // Standardkategorie anlegen
            table.Rows.Add(0, "Allgemein");

            // Tabelle an die DB anhängen
            texList.Tables.Add(table);

            // 1:n Beziehung zwischen der Tabelle category und texture
            rel = new DataRelation("textures to category", texList.Tables["category"].Columns["cid"], texList.Tables["texture"].Columns["cid"]);
            texList.Relations.Add(rel);

            // alle Änderungen in der DB übernehmen
            texList.AcceptChanges();

            // die Tabelle füllen
            ShowData();
        }

        private bool OpenTextures()
        {
            if (File.Exists(texFile) == true)
            {
                // die beiden dataGridViews leeren
                tabTexturen.Columns.Clear();
                tabKategorien.Columns.Clear();

                texList = new DataSet();

                //die komplette DB aus einer XML-Datei einlesen
                texList.ReadXml(texFile);

                // die Tabelle füllen
                ShowData();

                // Zeileneigenschaften anpassen
                ShowRowProperties(0, tabTexturen.Rows.Count - 1, false);

                ShowLoadCount();

                return true;
            }
            else
            {
                return false;
            }
        }

        private void ShowData()
        {
            // die Tabelle texture in einem dataGridView darstellen
            tabTexturen.DataSource = texList;
            tabTexturen.DataMember = texList.Tables[0].TableName;

            // die Tabelle category in einem dataGridView darstellen
            tabKategorien.DataSource = texList;
            tabKategorien.DataMember = texList.Tables[1].TableName;

            // die Spalte "cid" auf nur lesen stellen und ausblenden
            tabTexturen.Columns[4].ReadOnly = true;
            tabTexturen.Columns[4].Visible = false;
            tabKategorien.Columns[0].ReadOnly = true;
            tabKategorien.Columns[0].Visible = false;

            // die Spalte "colorkey" darf nicht manuell geändert werden
            tabTexturen.Columns[2].ReadOnly = true;

            // Spaltenüberschriften ändern
            tabTexturen.Columns[0].HeaderText = "Texturendatei";
            tabTexturen.Columns[1].HeaderText = "Blockgröße";
            tabTexturen.Columns[2].HeaderText = "Colorkey";
            tabTexturen.Columns[3].HeaderText = "Textur laden";
            tabKategorien.Columns[1].HeaderText = "Kategorie";

            // Texturen und Kategorien nach Name sortieren
            tabTexturen.Sort(tabTexturen.Columns[0], ListSortDirection.Ascending);
            tabKategorien.Sort(tabKategorien.Columns[1], ListSortDirection.Ascending);

            // Die Spalten dürfen nicht manuell sortiert werden (Probleme mit den Zeilenmarkierungen)
            foreach (DataGridViewColumn col in tabTexturen.Columns)
            {
                col.SortMode = DataGridViewColumnSortMode.NotSortable;
            }

            // neue ComboBox mit einer Liste der cids erstellen
            CreateComboCatColumn();
        }

        private void CreateComboCatColumn()
        {
            // neue ComboBox mit einer Liste der cids erstellen
            DataGridViewComboBoxColumn comboCatColumn = new DataGridViewComboBoxColumn();
            comboCatColumn.DataSource = texList.Tables[1]; // Tabelle category
            comboCatColumn.ValueMember = texList.Tables[1].Columns[0].ColumnName; // Feld category.cid wird gespeichert
            comboCatColumn.DisplayMember = texList.Tables[1].Columns[1].ColumnName;  // Feld category.name wird dargestellt
            comboCatColumn.HeaderText = "Kategorie";
            tabTexturen.Columns.Add(comboCatColumn);
        }

        private void ShowRowProperties(int minRow, int maxRow, bool neu)
        {
            // Zeilen von minRow bis maxRow durchlaufen...
            for (int i = minRow; i <= maxRow; i++)
            {
                // wenn die Texturdatei nicht existiert die Zeile rot markieren und den Haken bei "laden" abwählen
                if (File.Exists(Path.Combine(txtTexturenPfad.Text, tabTexturen[0, i].Value.ToString())) == false)
                {
                    tabTexturen.Rows[i].DefaultCellStyle.BackColor = Color.FromArgb(255, 128, 128);
                    tabTexturen.Rows[i].Cells[3].Value = false;
                }
                else
                {
                    // Zeile gelb markieren und Textur auf nicht laden setzen, wenn der Dateiname zu lang ist
                    if (tabTexturen.Rows[i].Cells[0].Value.ToString().Length > 9)
                    {
                        tabTexturen.Rows[i].DefaultCellStyle.BackColor = Color.FromArgb(255, 255, 128);
                        tabTexturen.Rows[i].Cells[3].Value = false;
                    }
                    else
                    {
                        if (neu == true)
                        {
                            // Hintergrundfarbe auf grün setzen
                            tabTexturen.Rows[i].DefaultCellStyle.BackColor = Color.FromArgb(128, 255, 128);
                        }
                        else
                        {
                            tabTexturen.Rows[i].DefaultCellStyle.BackColor = Color.White;
                        }
                    }
                }
                // Hintergrundfarbe der Zelle für den Colorkey darstellen
                tabTexturen.Rows[i].Cells[2].Style.BackColor = Color.FromArgb(Convert.ToInt32(tabTexturen.Rows[i].Cells[2].Value));
                // die Voruswahl der ComboBox auf die aktuelle cid setzten
                tabTexturen[5, i].Value = tabTexturen[4, i].Value;
            }
        }

        // ermittel den Zeilenindex anhand des Texturnamens
        private int GetRowIndex(string name)
        {
            int index = 0;
            for (int i = 0; i < tabTexturen.Rows.Count; i++)
            {
                if (tabTexturen[0, i].Value.ToString() == name)
                {
                    index = i;
                    break;
                }
            }
            return index;
        }

        // läd neue Texturen aus dem Texturenverzeichnis
        private void LoadTextures(string texPath)
        {
            if (Directory.Exists(texPath) == true)
            {
                string[] filePaths = Directory.GetFiles(texPath, "*.png");
                string fileName;
                DataRow[] erg;
                Bitmap bmp;
                int anzahl = 0, zeile;
                if (filePaths.Length > 0)
                {
                    for (int i = 0; i < filePaths.Length; i++)
                    {
                        fileName = Path.GetFileName(filePaths[i]);
                        erg = texList.Tables[0].Select(String.Format("name = '{0}'", fileName));
                        if (erg.Length == 0) // wenn die Textur noch NICHT in der Tabelle eingetragen wurde
                        {
                            // Standardwerte
                            texList.Tables[0].Rows.Add(fileName, 16, Color.Black.ToArgb().ToString(), true, 0);
                            zeile = GetRowIndex(fileName);
                            bmp = new Bitmap(filePaths[i]);
                            if (bmp.Width > 288 && bmp.Height > 128)
                            {
                                tabTexturen[2, zeile].Value = bmp.GetPixel(288, 128).ToArgb().ToString();
                            }
                            // Zeileneigenschaften anpassen
                            ShowRowProperties(zeile, zeile, true);
                            anzahl++;
                        }
                    }
                    if (anzahl > 0)
                    {
                        ShowLoadCount();
                        status.Text = "Es wurden " + anzahl + " neue Texturen geladen.";
                    }
                    else
                    {
                        status.Text = "In dem Texturenverzeichnis wurden keine neuen Texturen (PNG-Bilder) gefunden.";
                    }
                }
                else
                {
                    status.Text = "In dem Texturenverzeichnis wurden keine Texturen (PNG-Bilder) gefunden.";
                }
            }
        }

        private void contextMenuTexturen_Opening(object sender, CancelEventArgs e)
        {
            if (tabTexturen.Rows.Count > 0 && selRow >= 0)
            {
                textureToolStripMenuItem.Text = tabTexturen.Rows[selRow].Cells[0].Value.ToString();
                umbenennenToolStripTextBox.Text = textureToolStripMenuItem.Text;
            }
            else
            {
                e.Cancel = true;
            }
        }

        private void umbenennenToolStripTextBox_KeyPress(object sender, KeyPressEventArgs e)
        {
            try
            {
                if (e.KeyChar == 13) // Enter
                {
                    string sourcePath = Path.Combine(txtTexturenPfad.Text, tabTexturen.Rows[selRow].Cells[0].Value.ToString());
                    string destPath = Path.Combine(txtTexturenPfad.Text, umbenennenToolStripTextBox.Text);
                    if (File.Exists(sourcePath) == true)
                    {
                        if (File.Exists(destPath) == false)
                        {
                            File.Move(sourcePath, destPath);
                            contextMenuTexturen.Close();
                            status.Text = "Die Texturendatei wurde von \"" + tabTexturen.Rows[selRow].Cells[0].Value.ToString() + "\" in \"" + umbenennenToolStripTextBox.Text + "\" umbenannt.";
                            tabTexturen.Rows[selRow].Cells[0].Value = umbenennenToolStripTextBox.Text;
                            ShowRowProperties(selRow, selRow, true);
                        }
                        else
                        {
                            MessageBox.Show("Die Texturendatei \"" + Path.GetFileName(sourcePath) + "\" konnte nicht in \"" + Path.GetFileName(destPath) + "\" umbenannt werden, weil schon eine Datei mit diesem Namen existiert!", "Fehler beim Umbenennen", MessageBoxButtons.OK, MessageBoxIcon.Error);
                        }
                    }
                }
            }
            catch (IOException ex)
            {
                MessageBox.Show(ex.Message, "Fehler beim Umbenennen", MessageBoxButtons.OK, MessageBoxIcon.Error);
            }
        }

        private void alleZumLadenMarkierenToolStripMenuItem_Click(object sender, EventArgs e)
        {
            for (int i = 0; i < tabTexturen.Rows.Count; i++)
            {
                if (File.Exists(Path.Combine(txtTexturenPfad.Text, tabTexturen.Rows[i].Cells[0].Value.ToString())) == true && tabTexturen.Rows[i].Cells[0].Value.ToString().Length <= 9)
                {
                    tabTexturen.Rows[i].Cells[3].Value = true;
                }
            }
            ShowLoadCount();
        }

        private void keinenZumLadenMarkierenToolStripMenuItem_Click(object sender, EventArgs e)
        {
            for (int i = 0; i < tabTexturen.Rows.Count; i++)
            {
                tabTexturen.Rows[i].Cells[3].Value = false;
            }
            ShowLoadCount();
        }

        #endregion

    }
}
